﻿using IniParser.Model;
using IniParser;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.Json.Nodes;
using System.Text.Json;
using System.Threading.Tasks;
using System.Xml.Linq;

namespace CSharpTest
{
    public class CovertJsonIni
    {

        public static string ConvertIniToJson(string iniFilePath)
        {
            // 读取 INI 文件（宽松模式）
            var parser = new FileIniDataParser();
            parser.Parser.Configuration.AllowDuplicateKeys = true;
            parser.Parser.Configuration.SkipInvalidLines = true;

            IniData iniData = parser.ReadFile(iniFilePath);

            // 创建 JSON 根对象
            var jsonObject = new JsonObject();

            // 处理全局键值对
            foreach (var key in iniData.Global)
            {
                AddToJsonObject(jsonObject, key.KeyName, key.Value);
            }

            // 处理各个 section
            foreach (var section in iniData.Sections)
            {
                var sectionObject = new JsonObject();

                foreach (var key in section.Keys)
                {
                    AddToJsonObject(sectionObject, key.KeyName, key.Value);
                }

                jsonObject[section.SectionName] = sectionObject;
            }

            // 转换为格式化的 JSON 字符串
            return jsonObject.ToJsonString(new JsonSerializerOptions
            {
                WriteIndented = true,
                Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping
            });
        }

        private static void AddToJsonObject(JsonObject jsonObject, string key, string value)
        {
            // 尝试解析 JSON 结构
            if (IsJsonString(value))
            {
                try
                {
                    var jsonNode = JsonNode.Parse(value);
                    jsonObject[key] = jsonNode;
                    return;
                }
                catch { /* 如果不是有效 JSON，继续作为字符串处理 */ }
            }

            // 处理点号分隔的嵌套键
            if (key.Contains('.'))
            {
                var parts = key.Split('.');
                var current = jsonObject;

                for (int i = 0; i < parts.Length - 1; i++)
                {
                    if (!current.TryGetPropertyValue(parts[i], out var nextNode))
                    {
                        nextNode = new JsonObject();
                        current[parts[i]] = nextNode;
                    }

                    current = nextNode?.AsObject() ?? throw new InvalidOperationException("Invalid key path");
                }

                current[parts[1]] = JsonValue.Create(value);
            }
            else
            {
                // 简单键值对
                jsonObject[key] = JsonValue.Create(value);
            }
        }

        private static bool IsJsonString(string input)
        {
            input = input.Trim();
            return (input.StartsWith("{") && input.EndsWith("}")) ||
                   (input.StartsWith("[") && input.EndsWith("]"));
        }

        public static void ConvertJsonToIni(string jsonString, string outputIniPath)
        {
            // 解析 JSON 数据
            JsonNode jsonNode = JsonNode.Parse(jsonString) ?? throw new ArgumentException("Invalid JSON string");

            // 创建 INI 数据模型
            IniData iniData = new IniData();

            // 遍历 JSON 所有属性
            foreach (var property in jsonNode.AsObject())
            {
                ProcessJsonNode(iniData, property.Key, property.Value);
            }

            // 写入 INI 文件
            var parser = new FileIniDataParser();
            parser.WriteFile(outputIniPath, iniData);
        }

        private static void ProcessJsonNode(IniData iniData, string key, JsonNode node)
        {
            switch (node)
            {
                case JsonObject obj:
                    // 处理对象 - 创建 section
                    foreach (var prop in obj.AsObject())
                    {
                        ProcessJsonNode(iniData, $"{key}.{prop.Key}", prop.Value);
                    }
                    break;

                case JsonArray array:
                    // 处理数组 - 存储为 JSON 字符串
                    iniData.Global[key] = array.ToJsonString();
                    break;

                default:
                    // 处理基本类型
                    iniData.Global[key] = node?.ToString() ?? "";
                    break;
            }
        }
    }
}
